﻿namespace ProblemsSet
{
    public class Problem_128 : BaseProblem
    {
        public override object GetResult()
        {
            const int max = 2000;
            long n = 0;
            long cnt = 0;
            while(true)
            {
                n++;
                var tmp = ProveFirst(n);
                if (tmp > 0)
                {
                    cnt++;
                    if (cnt == max)
                        return tmp;
                }
                tmp = ProveSecond(n);
                if (tmp > 0)
                {
                    cnt++;
                    if (cnt == max)
                        return tmp;
                }
            }
        }

        private static long ProveFirst(long n)
        {
            if (!MathLogic.IsPrimeNumber(6 * n - 1)) return -1;
            if (!MathLogic.IsPrimeNumber(6 * n + 1)) return -1;
            if (!MathLogic.IsPrimeNumber(12 * n + 5)) return -1;
            return 2 + 3*n*(n - 1);
        }

        private static long ProveSecond(long n)
        {
            if (!MathLogic.IsPrimeNumber(6 * n - 1)) return -1;
            if (!MathLogic.IsPrimeNumber(12 * n - 7)) return -1;
            if (!MathLogic.IsPrimeNumber(6 * n + 5)) return -1;
            return 1 + 3 * n * (n + 1);
        }

        public override string Problem
        {
            get
            {
                return @"A hexagonal tile with number 1 is surrounded by a ring of six hexagonal tiles, starting at '12 o'clock' and numbering the tiles 2 to 7 in an anti-clockwise direction.

New rings are added in the same fashion, with the next rings being numbered 8 to 19, 20 to 37, 38 to 61, and so on. The diagram below shows the first three rings.


By finding the difference between tile n and each its six neighbours we shall define PD(n) to be the number of those differences which are prime.

For example, working clockwise around tile 8 the differences are 12, 29, 11, 6, 1, and 13. So PD(8) = 3.

In the same way, the differences around tile 17 are 1, 17, 16, 1, 11, and 10, hence PD(17) = 2.

It can be shown that the maximum value of PD(n) is 3.

If all of the tiles for which PD(n) = 3 are listed in ascending order to form a sequence, the 10th tile would be 271.

Find the 2000th tile in this sequence.";
            }
        }

        public override bool IsSolved
        {
            get
            {
                return true;
            }
        }

        public override object Answer
        {
            get
            {
                return 14516824220;
            }
        }
    }
}
